/*
 * F_DirectoryEntries.c
 *
 *  Created on: 04/11/2011
 *      Author: tacho
 */


#include "../../headers/GlobalHeaderPFS.h"
#include "../../headers/Constantes_PFS.h"

extern int32_t cantEntradasDir;
extern int32_t cantEntradasDirMax;
extern tDirectoryEntry entradaDelDirectorioActual;

/*-------------------------------------------------------------------------*/
/**
 Devuelve la LongDirectoryEntry y la DirectoryEntry de un archivo
 mediante su PATH.
 */
uint8_t obtenerEntradaAPartirDePATH(const char * path,
		tDirectoryEntries * entradasDelArchivo) {

	if(cantEntradasDir>0){
		if(leerEntradaDirCache(path,entradasDelArchivo)){
			return 1;
		}
	}
	char nombre[15];
	ultimoPath(path,nombre);
	char nombreDir[15];
	tDirectoryEntry * fileEntry= &(entradasDelArchivo->directoryEntry);
	tDirectoryEntry entradaDelDirectorioTemp=entradaDelDirectorioActual;
	tLongDirectoryEntry fileLongEntry;
	if (strcmp(path, "/") == 0) {
		entradaDeRootDirectory(&(*fileEntry));
		entradaDelDirectorioActual=*fileEntry;
		//*entradasDelArchivo->longDirectoryEntry;
		entradasDelArchivo->directoryEntry=*fileEntry;
		//free(nombre);
		return 1;
	}
	tNodoSubPaths * listaSubsPaths = armarSubsPaths(path);
	tNodoSubPaths * listaSubsPathsTemp = listaSubsPaths;
	uint32_t noExiste = 0;
	uint32_t encontrado= 0;
	if (strcmp((listaSubsPaths->subPath), "/") == 0) {
		entradaDeRootDirectory(&entradaDelDirectorioTemp);
		listaSubsPathsTemp = listaSubsPaths->sgte;
	}
	tListaEntradasDeDirectorios * listaDeEntradasTemp=NULL;
	tListaEntradasDeDirectorios * p=NULL;
	while ((listaSubsPathsTemp != NULL) && (noExiste == 0)) {
		listaDeEntradasTemp = cargarListaDeEntradasAPartirDe(obtenerDireccionPrimerCluster(&entradaDelDirectorioTemp));
		p = listaDeEntradasTemp;
		while ((listaDeEntradasTemp != NULL) && (encontrado == 0)) {
				nombreDelDirectorio(listaDeEntradasTemp,nombreDir);
			if (strcmp(nombreDir,listaSubsPathsTemp->subPath)==0) {
				entradaDelDirectorioTemp = listaDeEntradasTemp->directoryEntry;
				encontrado = 1;
				//la condicion siguiente, es cuando por medio de un path relativo,se llega
				//al directorio raiz, donde la direccion es nula en dicha entrada
				//para solucionar dicho problema se creo la entrada RootDirectory
				if(listaDeEntradasTemp->tieneEntradaLarga){
					fileLongEntry = listaDeEntradasTemp->longDirectoryEntry;
				}
				if((obtenerDireccionPrimerCluster(&entradaDelDirectorioTemp)==0)&&(listaDeEntradasTemp->directoryEntry.atributos==0x10)){
				entradaDeRootDirectory(&entradaDelDirectorioTemp);
				}
			}
			//p = listaDeEntradasTemp;
			listaDeEntradasTemp =listaDeEntradasTemp->sgte;
			//free(p);
			//if (p != NULL) free(p);
		}
		if ((encontrado == 0) && (listaDeEntradasTemp == NULL)) {
			noExiste = 1;
			//if(listaDeEntradasTemp!=NULL){
			//	p=listaDeEntradasTemp;
			//	listaDeEntradasTemp =NULL;
			borrarListasDeEntradas(&p);
			//}
			vaciarSubsPaths(&listaSubsPaths);
			//free(nombre);
			return 0;
		} else {
			borrarListasDeEntradas(&p);
			listaSubsPathsTemp = listaSubsPathsTemp->sgte;
			encontrado=0;
		}
		}
	vaciarSubsPaths(&listaSubsPaths);
	entradaDelDirectorioActual= entradaDelDirectorioTemp;
	entradasDelArchivo->directoryEntry =entradaDelDirectorioTemp;
	entradasDelArchivo->longDirectoryEntry =fileLongEntry;
	if(cantEntradasDirMax>0)agregarEntradasDirCache(path,entradasDelArchivo);
	//free(nombre);
	return 1;
}



/*-------------------------------------------------------------------------*/
/**
 Devuelve la lista de entradas de directorio pertenecientes a un
 directorio, recibiendo solo el clusters de inicio de dicho directorio.
 */
tListaEntradasDeDirectorios * cargarListaDeEntradasAPartirDe(
		uint32_t nroCluster) {

	tListaEntradasDeDirectorios * directorio;
	tListaEntradasDeDirectorios *nodoAnt;
	tListaEntradasDeDirectorios *nodoActual;
	tnodoEntrada cadena = NULL;
	tnodoEntrada cadenaAux;
	crearCadenaClusterAPartir(nroCluster, &cadena); /*se obtiene la cadena de cluster pertenecientes al archivo*/

	tCluster contenidoCluster;

	cadenaAux = cadena; /*se crea una cadena para realizar un corrimiento en sus elementos*/

	while (cadenaAux != NULL) { /*en este ciclo, se cargan todas las entradas pertenecientes a los cluster del directorio*/

		//pedirCluster(cadenaAux->entrada, &contenidoCluster);
		pedirLecturaDeCluster(cadenaAux->entrada,&contenidoCluster);
		uint32_t i;
		tDirectoryEntry directoryEntryTemp;
		nodoActual=NULL;
		nodoAnt=NULL;
		directorio = NULL;
		uint32_t estoyEnEntrada = 0;
		for (i = 0; i < sizeof(tCluster); i += sizeof(tDirectoryEntry)) {
			//Siempre hay una LongDirectoryEntry antes que una DirectoryEntry
			memcpy(&directoryEntryTemp, &contenidoCluster.bufferCluster[i],
					sizeof(tDirectoryEntry));

			if (directoryEntryTemp.name[0] == 0) { //Terminaron la entradas del archivo
				vaciarCadenaClusters(&cadena);
				return directorio;
			}
			if (/*directoryEntryTemp.name[0] != 0x2E &&*/ directoryEntryTemp.name[0]!= 0xE5) {
				if (!estoyEnEntrada) {
					nodoActual = (tListaEntradasDeDirectorios *) malloc(sizeof(tListaEntradasDeDirectorios));
					//Falta implementacion de esta funcion para llenar todo d 0
					//memset(&nodoActual,0,sizeof(tListaEntradasDeDirectorios));
					nodoActual->tieneEntradaLarga= 0;
					estoyEnEntrada = 1;
				}

					if (directoryEntryTemp.atributos == 0x0F) { // LongDirectoryEntry
						memcpy(&(nodoActual->longDirectoryEntry),
								&directoryEntryTemp,
								sizeof(tLongDirectoryEntry));
						nodoActual->tieneEntradaLarga =1;

					} else { //DirectoryEntry
						memcpy(&(nodoActual->directoryEntry),
								&directoryEntryTemp, sizeof(tDirectoryEntry));
						estoyEnEntrada = 0;
						if (nodoAnt != NULL) {
							nodoAnt->sgte = nodoActual;
						} else {
							directorio = nodoActual;
						}
						nodoActual->sgte = NULL;
						nodoAnt = nodoActual;

					}

				}

			}
		cadenaAux = cadenaAux->sgte;
		}
	vaciarCadenaClusters(&cadena);
		return directorio;
	}

/*-------------------------------------------------------------------------*/
/**

 */
tListaEntradasDeDirectorios * obtenerListaDelRootDirectory() {
	//Se sabe que el inicio de la dataRegion es el cluster 2 de la fatRegion
	//este magicnumber todavia es parte de una practica indebida del pedirCluster
	//cuando se logre la implementacion con el PPD, se solucionara
	tListaEntradasDeDirectorios * listaEntradas = cargarListaDeEntradasAPartirDe(2);
	return listaEntradas;
}

/*-------------------------------------------------------------------------*/
/**

 */
void borrarListasDeEntradas(tListaEntradasDeDirectorios ** listaDeEntries){
	tListaEntradasDeDirectorios * p;
	while((*listaDeEntries)!=NULL && (listaDeEntries !=NULL)){
		p=(*listaDeEntries);
		*listaDeEntries=(*listaDeEntries)->sgte;
		//if(p->sgte!=NULL)free(p);
		//p = realloc(p,0);
		free(p);
		p=NULL;
	}
}

/*-------------------------------------------------------------------------*/
/**
Devuelve el nombre de un archivo mediante sus entradas de directorio
(todavia falta su completa funcionalidad, se debe solucionar el problema
con nombres mayores a 5 caracteres)
 */
int32_t nombreDelDirectorio(tListaEntradasDeDirectorios * nodoDeLaLista,char * nombreArch) {
	//char * name;
	char name[20];
	if (nodoDeLaLista->tieneEntradaLarga == 1) {
		uint32_t actual = 0,actual1=0,actual2=0;
		uint32_t total = 0;
		uint8_t nombre[5];
		uint8_t termino = 1;
		memset(&nombre,0,sizeof(nombre));
		while (nodoDeLaLista->longDirectoryEntry.name[actual]!= 0 && (actual < 5) && termino) {
			nombre[actual] =
					(uint8_t) nodoDeLaLista->longDirectoryEntry.name[actual];
			actual++;
			total++;
		}
		if((actual<5)&&(nodoDeLaLista->longDirectoryEntry.name[actual]== 0)){
			termino = 0;
		}
		uint8_t nombre1[6];
		memset(&nombre1,0,sizeof(nombre1));
		//actual = 0;
		while ((nodoDeLaLista->longDirectoryEntry.name2[actual1] != 0)
				&& (actual1 < 6) && termino) {
			nombre1[actual1] =
					(uint8_t) nodoDeLaLista->longDirectoryEntry.name2[actual1];
			actual1++;
			total++;
		}
		if((actual1<6)&&(nodoDeLaLista->longDirectoryEntry.name2[actual1]== 0)){
					termino = 0;
		}
		uint8_t nombre2[2];
		memset(&nombre2,0,sizeof(nombre2));
		//actual = 0;
		while ((nodoDeLaLista->longDirectoryEntry.name3[actual2] != 0)
				&& (actual2 < 2) && termino) {
			nombre2[actual2] =
					(uint8_t) nodoDeLaLista->longDirectoryEntry.name3[actual2];
			actual2++;
			total++;
		}
		//if(name!=NULL){
		//	name=NULL;
		//}
		//name = (char *) malloc(total+1);
		//char name[total+1];
		//char name[total+1];
		//strcpy(name, nombre);
		memcpy(name, nombre,actual);
		if (total > 5) {
				memcpy(&name[5],&nombre1, actual1);
			//strcpy(name[5], nombre1);
		}
		if (total > 11) {
			//strcpy(name[11], nombre2);
			memcpy(&name[11],&nombre2, actual2);
		}
		name[total]='\0';

		//char nombreCompleto[total];
		//strcpy(nombreCompleto,name);
		//free(name);
		strcpy(nombreArch,name);
		return 0;
	} else {

	uint32_t noPathRelativo=0;
	//name = (char *) malloc(sizeof(nodoDeLaLista->directoryEntry.name));
	uint32_t var = 0;
	while(nodoDeLaLista->directoryEntry.name[var]!=' '&&var<8){
		var++;
	}
	strcpy(name, nodoDeLaLista->directoryEntry.name);//,var);
	if(nodoDeLaLista->directoryEntry.extension[0]!=' '){
		name[var]='.';
		strcpy(name+var+1, nodoDeLaLista->directoryEntry.extension);//,3);//strlen(nodoDeLaLista->directoryEntry.extension));
		name[var+4]='\0';
	}
	char nombre[3];
	memcpy(nombre,name,sizeof(char[3]));
	if((strcmp(nombre,". "))==0){
		strcpy(nombreArch,".");
		nombreArch[1]='\0';
		return 0;
	}
	if((strcmp(nombre,".."))==0){
		strcpy(nombreArch,"..");
		nombreArch[2]='\0';
		return 0;
	}
	if(noPathRelativo==0){
		strcpy(nombreArch,name);
		return 0;
		}
	}
	return 0;

}


/*-------------------------------------------------------------------------*/
/**
Se crea una entrada de directorio raiz, para aquellos casos se la necesita para
la creacion de la lista de directorios de "/" (RootDirectory). De esta forma,
se logra un polimorfismo con el uso de la funcion que carga dichas entradas.
 */
void entradaDeRootDirectory(tDirectoryEntry * entradaDelDirectorioRaiz) {
	memset(entradaDelDirectorioRaiz, 0, sizeof(tDirectoryEntry));
	entradaDelDirectorioRaiz->name[0] = 0;
	entradaDelDirectorioRaiz->atributos = 0x10;
	entradaDelDirectorioRaiz->size = TAMANO_CLUSTER;
	entradaDelDirectorioRaiz->dirFirstClusterHI = 0;
	entradaDelDirectorioRaiz->dirFirstClusterLO = 2;
}



/*-------------------------------------------------------------------------*/
/**
Busca el cluster donde se encuentran dichas entradas de directorio a reemplazar que se
 consiguen mediante su PATH. Encontrado dicho cluster, se reemplazan por las nuevas.
 Y se escribe dicho cluster.
 */
uint8_t reemplazarEntradaDelArchivo(char * path, tDirectoryEntries* entradasDelArchivoActualizadas) {

	if(cantEntradasDir>0){
		borrarEntradaDirCache(path);
		if(entradasDelArchivoActualizadas->directoryEntry.name[0]!=0xE5){
			agregarEntradasDirCache(path,entradasDelArchivoActualizadas);
		}
	}

	tDirectoryEntries entradasDelDirectorioPadre;
	//char * pathSinUltimo = eliminarUltimoSubPaths(path);
	char pathSinUltimo[50];
	eliminarUltimoSubPaths(path,pathSinUltimo);
	obtenerEntradaAPartirDePATH(pathSinUltimo,&entradasDelDirectorioPadre);
	//char * ultimoSubPath = ultimoPath(path);
	char ultimoSubPath[20];
	ultimoPath(path,ultimoSubPath);
	tnodoEntrada cadena = NULL;
	tnodoEntrada cadenaAux;
	crearCadenaClusterAPartir(obtenerDireccionPrimerCluster(&entradasDelDirectorioPadre.directoryEntry), &cadena); /*se obtiene la cadena de cluster pertenecientes al archivo*/
	char nombreDir[20];
	tCluster contenidoCluster;
	cadenaAux = cadena;

	tDirectoryEntry directoryEntryTemp;

	tListaEntradasDeDirectorios entradasActuales;
	entradasActuales.sgte = NULL;

	while (cadenaAux != NULL) {

		//pedirCluster(cadenaAux->entrada, &contenidoCluster);
		pedirLecturaDeCluster(cadenaAux->entrada, &contenidoCluster);
		uint32_t i;
		uint32_t estoyEnEntrada = 0;

		for (i = 0; i < sizeof(tCluster); i += sizeof(tDirectoryEntry)) {
			//Siempre hay una LongDirectoryEntry antes que una DirectoryEntry
			memcpy(&directoryEntryTemp, &contenidoCluster.bufferCluster[i],
					sizeof(tDirectoryEntry));
			if (directoryEntryTemp.name[0] == 0) { //Terminaron la entradas del archivo
				vaciarCadenaClusters(&cadena);
				return 0;
			}
			if (/*directoryEntryTemp.name[0] != 0x2E &&*/directoryEntryTemp.name[0]
					!= 0xE5) {
				if (!estoyEnEntrada) {
					estoyEnEntrada = 1;
					entradasActuales.tieneEntradaLarga = 0;
				}
				if (directoryEntryTemp.atributos == 0x0F) { // LongDirectoryEntry

					memcpy(&entradasActuales.longDirectoryEntry,
							&directoryEntryTemp, sizeof(tLongDirectoryEntry));
					entradasActuales.tieneEntradaLarga = 1;

				} else { //DirectoryEntry
					memcpy(&entradasActuales.directoryEntry,
							&directoryEntryTemp, sizeof(tDirectoryEntry));
					estoyEnEntrada = 0;
					nombreDelDirectorio(&entradasActuales,nombreDir);
					if (strcmp(nombreDir,
							ultimoSubPath) == 0) {
						memcpy(
							&contenidoCluster.bufferCluster[i - 32],
								&entradasDelArchivoActualizadas->longDirectoryEntry,
								sizeof(tLongDirectoryEntry));
						memcpy(&contenidoCluster.bufferCluster[i],
								&entradasDelArchivoActualizadas->directoryEntry,
								sizeof(tDirectoryEntry));
						//free(pathSinUltimo);
						uint32_t entrada = cadenaAux->entrada;
						vaciarCadenaClusters(&cadena);
						return pedirEscrituraDeCluster(entrada, &contenidoCluster);
						//return 1;
					}
				}
			}
		}
		cadenaAux = cadenaAux->sgte;

	}
	vaciarCadenaClusters(&cadena);
	//free(pathSinUltimo);
	return 0;

}

/*-------------------------------------------------------------------------*/
/**
Devuelve el nro del byte del cluster de inicio del espacio libre para la cantidad
de entradas que tengamos que agregar.
 */
uint32_t buscarDirectoryEntriesLibres(tCluster * contenidoCluster,uint32_t cantidadEntradas){
	tDirectoryEntry directoryEntry;

	uint32_t inicioLibre=0;
	uint32_t toyLibre=1;
	uint32_t cantSeguidasLibres = 0;

	uint32_t var;
	for(var=0;var<TAMANO_CLUSTER;var+=sizeof(tDirectoryEntry)){

		memcpy(&directoryEntry,&contenidoCluster->bufferCluster[var],sizeof(tDirectoryEntry));

		if( (directoryEntry.name[0]!=0) && (directoryEntry.name[0]!=0xE5)){
			cantSeguidasLibres=0;
			toyLibre = 0;
		}

		if ( (directoryEntry.name[0]==0) || (directoryEntry.name[0]==0xE5)){
			if(!toyLibre){
				toyLibre=1;
				inicioLibre=var;
				cantSeguidasLibres+=1;
			}else{
				cantSeguidasLibres+=1;
			}

		if(cantSeguidasLibres==cantidadEntradas){
			return inicioLibre;
		}
	}
	}
	return -10;
}

/*-------------------------------------------------------------------------*/
/**
Agrega la entrada de directorio, incluyendo su escritura al disco. (Falta prueba)
 */
uint32_t agregarDirectoryEntry(char * path,tDirectoryEntries * directoryAAgregar){
	tDirectoryEntries entradasDirectorio;
	obtenerEntradaAPartirDePATH(path,&entradasDirectorio);
	uint32_t nroCluster = obtenerDireccionPrimerCluster(&entradasDirectorio.directoryEntry);
	tCluster contenidoCluster;
	uint32_t inicioLibre;
	int32_t var =-1;
	//while(var<0){
	//pthread_mutex_lock(&mutex_array_nrosClusters);
	//var = estaEnArray(nroCluster);
	//if(var >= 0){
	//pthread_mutex_lock(&arrayNrosClusters[var].enUso);
	//arrayNrosClusters[var].nroCluster = nroCluster;
	//}
	//pthread_mutex_unlock(&mutex_array_nrosClusters);
//sleep(0.05);
	//}
	do {
		pedirLecturaDeCluster(nroCluster,&contenidoCluster);
		inicioLibre=buscarDirectoryEntriesLibres(&contenidoCluster,2);
		if (inicioLibre<0) {
		nroCluster = obtenerSiguienteCluster(nroCluster);
		}
		if(nroCluster == FAT_ULTIMO){
		pfs_truncar(path,entradasDirectorio.directoryEntry.size+TAMANO_CLUSTER);
		}
	} while (inicioLibre<0);
	//memset(&contenidoCluster,0,sizeof(tCluster));
	memcpy(&contenidoCluster.bufferCluster[inicioLibre],&directoryAAgregar->longDirectoryEntry,sizeof(tLongDirectoryEntry));
	memcpy(&contenidoCluster.bufferCluster[inicioLibre + sizeof(tLongDirectoryEntry)],&directoryAAgregar->directoryEntry,sizeof(tDirectoryEntry));
	pedirEscrituraDeCluster(nroCluster,&contenidoCluster);

	//pthread_mutex_lock(&mutex_array_nrosClusters);
	//pthread_mutex_unlock(&arrayNrosClusters[var].enUso);
	//pthread_mutex_unlock(&mutex_array_nrosClusters);

	return 1;
}

/*-------------------------------------------------------------------------*/
/**
Recibe el nombre nuevo, el cual se utiliza para reemplazar: en la directoryEntry la extension
y el nombre; y en la longDirectoryEntry, los diferentes campos de name
 */
uint32_t renombrarEntradas(char nombreNuevo[],tDirectoryEntries * entradaDir){

	char nombre[20];
	char extension[3];
	memset(nombre,'\0',20);
	memset(extension,' ',3);
	if(entradaDir->directoryEntry.atributos!=0x10){
         separarNombreExt(nombreNuevo,nombre,extension);
	}else{
		memcpy(nombre,nombreNuevo,20);
		//strcpy(nombre,nombreNuevo);
		memcpy(extension,"   ",3);
	}
	//Tratamiento de la DirectoryEntry
	char nombreCorto[8];
	memset(nombreCorto,' ',8);
    	int32_t var = 0;
    	while(nombre[var]!='\0'&&var<20){
    	//nombreEntradaDirec[var]=nombreCorto[var];
    	var++;
    	   	}
   //if (strlen(nombre)<= 8){

    if (var<= 8){
	   //memcpy(nombreCorto,nombre,strlen(nombre));
	   strcpy(nombreCorto,nombre);
	   //nombreCorto[8]='\0';
	}else{
			memcpy(nombreCorto,nombre,6);
			nombreCorto[6]='˜';
			nombreCorto[7]='\0';
			//nombreCorto[8]='\0';
	}
      char extensionMayus[3];
      memcpy(extensionMayus,extension,3);
      char nombreEntradaDirec[12];
      memset(nombreEntradaDirec,' ',12);
      // char nombreEntradaDirecSinExt[8];
      // memset(nombreEntradaDirec,' ',8);

//    if(extension[0]!=' '){
//      // char nombreEntradaDirec[12];
//    	int32_t var = 0;
//    	while(nombreCorto[var]!='\0'){
//    	nombreEntradaDirec[var]=nombreCorto[var];
//    	var++;
//    	   	}
//      // memcpy(nombreEntradaDirec,nombreCorto,8);
//    //	 nombreEntradaDirec[var]='.';
//    	 memcpy(nombreEntradaDirec+var,extension,3);
//       }else{
//        //	char nombreEntradaDirec[8];
//        memcpy(nombreEntradaDirecSinExt,nombreCorto,8);
//       }


        paseAMayuscula(nombreCorto);
		paseAMayuscula(extensionMayus);
	    strncpy(nombreEntradaDirec,nombreCorto,8);
	    strncpy(nombreEntradaDirec+8,extensionMayus,3);
	memcpy(entradaDir->directoryEntry.name,nombreCorto,8);
	memcpy(entradaDir->directoryEntry.extension, extensionMayus,3);
	//Tratamiento de la LongDirectoryEntry

		uint16_t nombreLargo[13];
		memset(nombreLargo,0,26);
		//uint32_t var;
		for (var = 0; var < strlen(nombreNuevo);var++) {
			nombreLargo[var]= (uint16_t) nombreNuevo[var];
		}

		memcpy(entradaDir->longDirectoryEntry.name,nombreLargo,10);
		memcpy(entradaDir->longDirectoryEntry.name2,&nombreLargo[5],12);
		memcpy(entradaDir->longDirectoryEntry.name3,&nombreLargo[11],4);
	    //  if(extension[0]!=' '){
	    	  entradaDir->longDirectoryEntry.chksum=lfn_checksum(nombreEntradaDirec);
	     //  }else{
	    //	   entradaDir->longDirectoryEntry.chksum=lfn_checksum(nombreEntradaDirecSinExt);
	     //  }



return 0;
	}

/*-------------------------------------------------------------------------*/
/**

 */
unsigned char lfn_checksum(const unsigned char *pFcbName)
{
        int i;
        unsigned char sum=0;

        for (i=11; i; i--)
                sum = ((sum & 1) << 7) + (sum >> 1) + *pFcbName++;
        return sum;
}

/*-------------------------------------------------------------------------*/
/**

 */
uint32_t agregarEntradasRelativas(tCluster * contenidoCluster,uint32_t nroPadre,uint32_t nroActual)
{
	tDirectoryEntry entradaPadre;
	tDirectoryEntry entradaHijo;
	memset(&entradaPadre,0,sizeof(tDirectoryEntry));
	memset(&entradaHijo,0,sizeof(tLongDirectoryEntry));
	entradaPadre.name[0]='.';
	entradaPadre.name[1]='.';
	entradaHijo.name[0]='.';
	entradaPadre.atributos=0x10;
	entradaHijo.atributos=0x10;
	agregarPrimerCluster(nroPadre,&entradaPadre);
	agregarPrimerCluster(nroActual,&entradaHijo);
	memcpy(contenidoCluster,&entradaHijo,sizeof(tDirectoryEntry));
	memcpy(&(contenidoCluster->bufferCluster[sizeof(tDirectoryEntry)]),&entradaPadre,sizeof(tDirectoryEntry));

	return 0;
}









